package com.yx.changdao.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yx.changdao.common.entity.SysPermission;
import com.yx.changdao.common.entity.SysRole;
import com.yx.changdao.common.entity.SysRolePermission;
import com.yx.changdao.common.exception.AlertException;
import com.yx.changdao.common.mapper.SysRolePermissionMapper;
import com.yx.changdao.common.utils.SysConst;
import com.yx.changdao.service.SysPermissionService;
import com.yx.changdao.service.SysRolePermissionService;
import com.yx.changdao.service.SysRoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * @Title: SysRolePermissionServiceImpl
 * @Description: 系统角色权限服务实现
 * @Auther: Zhangjiashun
 * @Version: 1.0
 * @create 2019/11/6 12:14
 */
@Service
public class SysRolePermissionServiceImpl extends ServiceImpl<SysRolePermissionMapper, SysRolePermission> implements SysRolePermissionService {
    @Autowired
    private SysRoleService sysRoleService;
    @Autowired
    private SysPermissionService sysPermissionService;


    /**
     * 添加角色
     *
     * @param roleId   角色id
     * @param roleName 角色名
     * @return 添加后的角色
     */
    @Override
    public SysRole addRole(String roleId, String roleName) {
        return this.sysRoleService.addRole(roleId, roleName);
    }

    /**
     * 添加角色 和添加者。
     *
     * @param roleId   角色id
     * @param roleName 角色名
     * @param createBy 添加者
     * @return 添加后的角色信息
     */
    @Override
    public SysRole addRole(String roleId, String roleName, String createBy) {
        return this.sysRoleService.addRole(roleId, roleName, createBy);
    }

    /**
     * 根据角色id获取角色
     *
     * @param roleId 角色id
     * @return 角色
     */
    @Override
    public SysRole getRole(String roleId) {
        return this.sysRoleService.getRole(roleId);
    }

    /**
     * 获取所有角色
     *
     * @return 角色列表
     */
    @Override
    public List<SysRole> getAllRoles() {
        return this.sysRoleService.getAllRoles();
    }

    /**
     * 获取所有角色id
     *
     * @return 角色id列表
     */
    @Override
    public List<String> getAllRoleIds() {
        List<SysRole> allRoles = this.getAllRoles();
        List<String> roles = new ArrayList<>();
        allRoles.forEach(role -> roles.add(role.getRoleId()));
        return roles;
    }

    /**
     * 添加权限
     *
     * @param permissionId   权限id
     * @param permissionName 权限名
     * @return 添加后的权限
     */
    @Override
    public SysPermission addPermission(String permissionId, String permissionName) {
        return this.sysPermissionService.addPermission(permissionId, permissionName);
    }

    /**
     * 根据权限id获取权限
     *
     * @param permissionId 权限id
     * @return 权限
     */
    @Override
    public SysPermission getPermission(String permissionId) {
        return this.sysPermissionService.getPermission(permissionId);
    }

    /**
     * 获取所有权限
     *
     * @return 权限列表
     */
    @Override
    public List<SysPermission> getAllPermissions() {
        return this.sysPermissionService.getAllPermissions();
    }

    /**
     * 获取所有权限id
     *
     * @return 权限id列表
     */
    @Override
    public List<String> getAllPermissionIds() {
        List<SysPermission> allPermissions = this.getAllPermissions();
        List<String> perms = new ArrayList<>();
        allPermissions.forEach(permission -> perms.add(permission.getPermId()));
        return perms;
    }


    /**
     * 添加角色权限
     *
     * @param role       角色
     * @param permission 权限
     * @return 角色权限
     */
    @Override
    public SysRolePermission addRolePermission(SysRole role, SysPermission permission) {
        return this.addRolePermission(role.getRoleId(), permission.getPermId());
    }

    /**
     * 添加角色权限
     *
     * @param roleId       角色id
     * @param permissionId 权限id
     * @return 添加后的角色权限
     */
    @Override
    public SysRolePermission addRolePermission(String roleId, String permissionId) {
        if (roleId == null || permissionId == null) {
            return null;
        }
        SysRolePermission srp = new SysRolePermission();
        srp.setPermId(permissionId);
        srp.setRoleId(roleId);

        return this.save(srp) ? srp : null;
    }

    /**
     * 添加角色权限
     *
     * @param rolePermission 角色色权限
     * @return 添加后的角色权限
     */
    @Override
    public SysRolePermission addRolePermission(SysRolePermission rolePermission) throws AlertException {
        if (rolePermission == null) {
            return null;
        }
        SysPermission permission = this.sysPermissionService.getPermission(rolePermission.getPermId());
        SysRole role = this.sysRoleService.getRole(rolePermission.getRoleId());
        if (permission == null) {
            throw new AlertException("不存在的权限信息。");
        }
        if (role == null) {
            throw new AlertException("不存在的角色信息。");
        }
        return this.addRolePermission(rolePermission.getRoleId(), rolePermission.getPermId());
    }

    /**
     * 获取角色权限列表
     *
     * @param roleId 角色id
     * @return 角色拥有的权限列表
     */
    @Override
    public List<SysPermission> getRolePermissions(String roleId) {

        // 如果是管理员角色返回所有权限
        if (SysConst.SYS_ROLE.equals(roleId)) {
            return this.sysPermissionService.getAllPermissions();
        }

        // 先根据 id 查询所有 SysRolePermission
        List<SysRolePermission> sysRolePermissions =
                this.list(new QueryWrapper<SysRolePermission>().lambda()
                        .eq(SysRolePermission::getRoleId, roleId));
        List<String> permIds = new ArrayList<>();
        for (SysRolePermission sysRolePermission : sysRolePermissions) {
            permIds.add(sysRolePermission.getPermId());
        }

        // 遍历 permissionId
        List<SysPermission> perm = new ArrayList<>();
        for (String permId : permIds) {
            SysPermission permission = this.getPermission(permId);
            if (null != permission) {
                perm.add(permission);
            }
        }
        return perm;
    }

    /**
     * 删除角色权限
     */
    @Override
    public Boolean delRolePermissions(String roleId, String permissionId) {
        return this.remove(new QueryWrapper<SysRolePermission>().lambda()
                .eq(SysRolePermission::getRoleId, roleId)
                .eq(SysRolePermission::getPermId, permissionId));
    }

    /**
     * 删除角色所有权限
     *
     * @param roleId 角色id
     * @return 是否删除成功
     */
    @Override
    public Boolean delRoleAllPermissions(String roleId) {
        return this.remove(new QueryWrapper<SysRolePermission>().lambda()
                .eq(SysRolePermission::getRoleId, roleId));
    }

    /**
     * 删除角色所有权限
     *
     * @param sysRole 角色
     * @return 是否删除成功
     */
    @Override
    public Boolean delRoleAllPermissions(SysRole sysRole) {
        return this.delRoleAllPermissions(sysRole.getRoleId());
    }

    /**
     * 删除角色权限
     */
    @Override
    public Boolean delRolePermissions(SysRolePermission rolePermission) {
        return this.delRolePermissions(rolePermission.getRoleId(), rolePermission.getPermId());
    }
}
